/**
 * 表单验证工具函数
 */

/**
 * 验证手机号
 * @param {string} phone 手机号
 * @returns {boolean} 是否有效
 */
export function validatePhone(phone) {
  return /^1[3-9]\d{9}$/.test(phone)
}

/**
 * 验证邮箱
 * @param {string} email 邮箱地址
 * @returns {boolean} 是否有效
 */
export function validateEmail(email) {
  return /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/.test(email)
}

/**
 * 验证身份证号
 * @param {string} idCard 身份证号
 * @returns {boolean} 是否有效
 */
export function validateIdCard(idCard) {
  return /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/.test(idCard)
}

/**
 * 验证密码强度
 * @param {string} password 密码
 * @returns {object} 包含强度等级和建议
 */
export function validatePassword(password) {
  const result = {
    score: 0,
    level: 'weak',
    suggestions: []
  }
  
  if (password.length < 6) {
    result.suggestions.push('密码长度至少6位')
  } else {
    result.score += 1
  }
  
  if (/[a-z]/.test(password)) {
    result.score += 1
  } else {
    result.suggestions.push('包含小写字母')
  }
  
  if (/[A-Z]/.test(password)) {
    result.score += 1
  } else {
    result.suggestions.push('包含大写字母')
  }
  
  if (/\d/.test(password)) {
    result.score += 1
  } else {
    result.suggestions.push('包含数字')
  }
  
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    result.score += 1
  } else {
    result.suggestions.push('包含特殊字符')
  }
  
  if (result.score >= 4) {
    result.level = 'strong'
  } else if (result.score >= 2) {
    result.level = 'medium'
  }
  
  return result
}

/**
 * 验证URL
 * @param {string} url URL地址
 * @returns {boolean} 是否有效
 */
export function validateUrl(url) {
  try {
    new URL(url)
    return true
  } catch {
    return false
  }
}

/**
 * 验证必填字段
 * @param {any} value 字段值
 * @param {string} fieldName 字段名称
 * @returns {object} 验证结果
 */
export function validateRequired(value, fieldName) {
  const isValid = value !== null && value !== undefined && value.toString().trim() !== ''
  return {
    isValid,
    message: isValid ? '' : `${fieldName}不能为空`
  }
}

/**
 * 验证字段长度
 * @param {string} value 字段值
 * @param {number} min 最小长度
 * @param {number} max 最大长度
 * @param {string} fieldName 字段名称
 * @returns {object} 验证结果
 */
export function validateLength(value, min, max, fieldName) {
  const length = value ? value.toString().length : 0
  
  if (min && length < min) {
    return {
      isValid: false,
      message: `${fieldName}长度不能少于${min}位`
    }
  }
  
  if (max && length > max) {
    return {
      isValid: false,
      message: `${fieldName}长度不能超过${max}位`
    }
  }
  
  return {
    isValid: true,
    message: ''
  }
}

/**
 * 批量验证表单
 * @param {object} formData 表单数据
 * @param {object} rules 验证规则
 * @returns {object} 验证结果
 */
export function validateForm(formData, rules) {
  const errors = {}
  let isValid = true
  
  for (const [field, fieldRules] of Object.entries(rules)) {
    const value = formData[field]
    
    for (const rule of fieldRules) {
      let fieldError = ''
      
      switch (rule.type) {
        case 'required':
          const requiredResult = validateRequired(value, rule.message || field)
          if (!requiredResult.isValid) {
            fieldError = requiredResult.message
          }
          break
          
        case 'phone':
          if (value && !validatePhone(value)) {
            fieldError = rule.message || '请输入正确的手机号'
          }
          break
          
        case 'email':
          if (value && !validateEmail(value)) {
            fieldError = rule.message || '请输入正确的邮箱地址'
          }
          break
          
        case 'length':
          const lengthResult = validateLength(value, rule.min, rule.max, rule.message || field)
          if (!lengthResult.isValid) {
            fieldError = lengthResult.message
          }
          break
          
        case 'custom':
          if (rule.validator && typeof rule.validator === 'function') {
            const customResult = rule.validator(value, formData)
            if (!customResult.isValid) {
              fieldError = customResult.message
            }
          }
          break
      }
      
      if (fieldError) {
        errors[field] = fieldError
        isValid = false
        break // 一个字段只显示第一个错误
      }
    }
  }
  
  return {
    isValid,
    errors
  }
} 